
// 导入CSS文件
import '../css/predict.css';
import { predictTest } from './predictApi';
// 导入axios库
import axios from 'axios';

// ===================== 关键修改1：从localStorage读取input页面保存的数据 =====================
// 读取input.js中存储的用户信息，生成请求数据（完全替代硬编码）
function getRequestDataFromLocalStorage() {
  try {
    // 1. 读取input.js保存的核心数据（key与input.js完全对齐）
    const userScoresStr = localStorage.getItem('userScores');
    const userMajor = localStorage.getItem('userMajor');
    const userCollege = localStorage.getItem('userCollege'); // 对应input.js的userCollege
    const userTargetSchool = localStorage.getItem('userTargetSchool');

    // 2. 校验必要数据是否存在（缺少则返回null，后续提示用户）
    if (!userScoresStr || !userMajor || !userCollege || !userTargetSchool) {
      log('localStorage缺少必要数据：请先在信息输入页填写并保存', 'error');
      return null;
    }

    // 3. 解析成绩数据（input.js中userScores存储了gpa、cet4等成绩）
    const userScores = JSON.parse(userScoresStr);

    // 4. 整合为后端需要的请求格式（字段名与原硬编码保持一致，确保后端能识别）
    return {
      name: "", // input.js未保存姓名，暂留空（可根据需求在input页补充字段）
      gpa: Number(userScores.gpa) || 0, // 转为数字，避免字符串类型
      cet4: Number(userScores.cet4) || 0,
      math1: Number(userScores.math1) || 0, // 非必需字段，缺失时默认0
      math2: Number(userScores.math2) || 0,
      english1: Number(userScores.english1) || 0,
      english2: Number(userScores.english2) || 0,
      english3: Number(userScores.english3) || 0,
      english4: Number(userScores.english4) || 0,
      Major: userMajor, // 对应input.js的userMajor
      college: userCollege, // 对应input.js的userCollege
      TargetSchool: userTargetSchool, // 对应input.js的userTargetSchool
      token: generateToken() // 生成随机token
    };
  } catch (error) {
    log(`读取localStorage失败：${error.message}`, 'error');
    return null;
  }
}

// 生成请求数据（从localStorage读取，而非硬编码）
const requestData = getRequestDataFromLocalStorage();

// 全局配置（保留原配置，确保API地址正确）
const CONFIG = {
  API_URL: '/api/v1/predict',
  DEBUG_MODE: true
};

// 工具函数：生成随机token
function generateToken() {
  const timestamp = Date.now();
  const randomStr = Math.random().toString(36).substring(2, 10);
  return `token_${timestamp}_${randomStr}`;
}

// ===================== 原有工具函数（保留，仅优化数据验证逻辑） =====================
// 工具函数：仅输出控制台日志（无页面提示）
function log(message, level = 'info') {
  if (CONFIG.DEBUG_MODE) {
    const timestamp = new Date().toISOString();
    const logMethod = level === 'error' ? console.error : console.log;
    logMethod(`[${timestamp}] [${level}] ${message}`);
  }
}

// 重置结果区域（仅清理DOM，无提示）
function resetResults() {
  const predictionDetails = document.getElementById('prediction-details');
  const schoolRecommendation = document.getElementById('school-recommendation');
  const buttonContainer = document.getElementById('recommendation-button-container');
  const errorContainer = document.getElementById('error-message');

  if (predictionDetails) predictionDetails.innerHTML = '<span style="color:#666;">正在获取预测数据...</span>';
  if (schoolRecommendation) schoolRecommendation.innerHTML = '';
  if (buttonContainer) buttonContainer.style.display = 'none';
  if (errorContainer) errorContainer.textContent = ''; // 清空历史错误
}

// 保存数据到localStorage（仅日志反馈，与input.js保持一致）
function saveDataToLocalStorage(data) {
  try {
    if (typeof localStorage !== 'undefined' && data) {
      localStorage.setItem('userScores', JSON.stringify(data));
      if (data.college) localStorage.setItem('userCollege', data.college); // 与input.js的key对齐
      if (data.Major) localStorage.setItem('userMajor', data.Major);
      if (data.TargetSchool) localStorage.setItem('userTargetSchool', data.TargetSchool);
      log('数据已更新到localStorage（与input.js同步）');
    }
  } catch (error) {
    log('localStorage保存失败: ' + error.message, 'warning');
  }
}

// 数据验证（适配从localStorage读取的数据，补充必要字段校验）
function validateFormData(data) {
  if (!data) {
    log('验证失败：无有效用户数据', 'error');
    return false;
  }

  // 1. 校验数字字段（确保是有效数字）
  const numericFields = ['gpa', 'cet4', 'math1', 'math2', 'english1', 'english2', 'english3', 'english4'];
  for (const field of numericFields) {
    if (typeof data[field] !== 'number' || isNaN(data[field]) || data[field] < 0) {
      log(`验证失败：${field} 必须是大于等于0的数字`, 'error');
      return false;
    }
  }

  // 2. 校验数值范围（与input.js的校验逻辑保持一致）
  if (data.gpa > 5.0 || data.cet4 > 750) {
    log('验证失败：GPA不能超过5.0，CET4不能超过750', 'error');
    return false;
  }
  const subjectFields = numericFields.filter(key => key.startsWith('math') || key.startsWith('english'));
  for (const field of subjectFields) {
    if (data[field] > 100) {
      log(`验证失败：${field} 成绩不能超过100分`, 'error');
      return false;
    }
  }

  // 3. 校验非数字必要字段（与input.js的保存字段对齐）
  if (!data.Major || !data.college || !data.TargetSchool) {
    log('验证失败：专业、学院、目标院校不能为空', 'error');
    return false;
  }

  return true;
}

// 发送预测请求（使用 axios 的优化版本，适配新的requestData）
function sendPredictionRequest() {
  log('Predict界面：发起预测请求 (axios)...');
  if (!validateFormData(requestData)) return; // 先校验数据

  resetResults();
  axios.post(CONFIG.API_URL, requestData, {
    headers: {
      'Content-Type': 'application/json'
    }
  })
    .then(response => {
      console.log("axios请求成功！后端返回数据：", response.data);
      processPredictionResult(response.data);
      saveDataToLocalStorage(requestData); // 同步更新localStorage
    })
    .catch(error => {
      console.error("axios请求失败：", error);
      let errorMsg = '请求失败';

      if (error.response) {
        errorMsg = `服务器错误: ${error.response.status} ${error.response.statusText}`;
        if (error.response.data) errorMsg += `\n后端提示: ${JSON.stringify(error.response.data)}`;
      } else if (error.request) {
        errorMsg = `未收到服务器响应: 请检查后端是否运行或代理配置是否正确`;
      } else {
        errorMsg = `请求配置错误: ${error.message}`;
      }

      const errorContainer = document.getElementById("error-message");
      if (errorContainer) {
        errorContainer.style.color = "red";
        errorContainer.textContent = errorMsg;
      }
    });
}

// ===================== 关键修改2：修复结果渲染，补充数据缺失提示 =====================
// 页面加载完成后自动执行（核心逻辑优化）
document.addEventListener('DOMContentLoaded', function () {
  // 先创建错误提示容器（避免无容器导致提示丢失）
  if (!document.getElementById('error-message')) {
    const errorDiv = document.createElement('div');
    errorDiv.id = 'error-message';
    errorDiv.style.margin = '1rem 0';
    errorDiv.style.fontSize = '0.9rem';
    // 插入到预测结果区域上方
    const resultSection = document.querySelector('.result-section');
    if (resultSection) resultSection.prepend(errorDiv);
  }

  // 确认当前是predict界面
  if (document.getElementById('prediction-details')) {
    log('确认当前为Predict界面，启动数据加载流程');

    // 1. 检查是否从localStorage获取到数据
    if (!requestData) {
      const errorContainer = document.getElementById("error-message");
      const predictionDetails = document.getElementById('prediction-details');
      if (errorContainer) {
        errorContainer.style.color = "red";
        errorContainer.textContent = '未找到用户信息，请先前往【个人信息与成绩输入】页面填写并保存';
      }
      if (predictionDetails) {
        predictionDetails.innerHTML = '<span style="color:#666;">需先填写个人信息才能预测</span>';
        // 可添加跳转链接（可选）
        predictionDetails.innerHTML += '<br><a href="/input.html" style="color:#1976d2;">点击前往信息输入页</a>';
      }
      return; // 无数据，终止后续流程
    }

    // 2. 验证数据有效性
    if (!validateFormData(requestData)) {
      const errorContainer = document.getElementById("error-message");
      if (errorContainer) {
        errorContainer.style.color = "red";
        errorContainer.textContent = '用户数据无效，请检查信息输入页的填写内容（如GPA、CET4格式）';
      }
      return;
    }

    // 3. 重置结果区域，发起请求（关键：调用processPredictionResult渲染页面）
    resetResults();
    predictTest(requestData)
      .then((res) => {
        log("predictTest请求成功，开始处理后端数据");
        console.log("后端返回原始数据：", res.data);
        // 核心修复：将后端数据传入处理函数，触发页面渲染
        processPredictionResult(res.data);
        saveDataToLocalStorage(requestData); // 同步数据到localStorage
      })
      .catch((error) => {
        log(`predictTest请求失败: ${error.message}`, 'error');
        console.error("请求失败详情：", error);
        let errorMsg = '获取预测数据失败';
        if (error.response) {
          errorMsg = `服务器错误 (${error.response.status})：请联系后端检查接口`;
        } else if (error.message.includes('Network')) {
          errorMsg = '网络错误：请检查Webpack代理配置或后端是否在线';
        }

        const errorContainer = document.getElementById("error-message");
        const predictionDetails = document.getElementById('prediction-details');
        if (errorContainer) {
          errorContainer.style.color = "red";
          errorContainer.textContent = errorMsg;
        }
        if (predictionDetails) {
          predictionDetails.innerHTML = '<span style="color:#666;">预测请求失败，请重试</span>';
        }
      });
  } else {
    log('未找到prediction-details元素，非Predict界面，终止流程', 'warning');
  }
});

// ===================== 关键修改3：处理预测结果（新增“积极调整型”判断标记） =====================
function processPredictionResult(data) {
  log('开始处理预测结果: ' + JSON.stringify(data));

  if (!data) {
    log('处理失败：API返回数据为空', 'error');
    const errorContainer = document.getElementById("error-message");
    if (errorContainer) errorContainer.textContent = '后端返回数据为空，请检查接口';
    return;
  }

  // 检查核心字段（prediction/probability），兼容后端可能的嵌套格式
  const realData = data.data ? data.data : data;
  if (typeof realData.prediction === 'undefined' || typeof realData.probability === 'undefined') {
    log(`结果结构不符合预期：缺少prediction/probability，原始数据: ${JSON.stringify(data)}`, 'error');
    const errorContainer = document.getElementById("error-message");
    if (errorContainer) errorContainer.textContent = '后端返回数据格式错误，缺少关键预测字段';
    return;
  }

  // 生成推荐并展示（触发页面渲染）
  // 关键修改：接收generateRecommendations返回的prediction
  const { recommendation, suggestions, level, prediction } = generateRecommendations(realData);
  // 关键修改：将prediction传递给displayResults
  displayResults(level, realData.probability, recommendation, suggestions, prediction);
  showRecommendationButton();
}

// ===================== 关键修改4：生成推荐（返回“积极调整型”判断标记） =====================
function generateRecommendations(data) {
  // 初始化返回对象
  let level = '';
  let recommendation = '';
  const suggestions = [];
  const { prediction } = data;

  // 根据预测结果和概率，生成不同类型的备考建议
  if (data.prediction === 1) { // 预测为 985/211 院校
    if (data.probability >= 85) {
      // 一、潜力出众型（985/211 上岸概率 ≥ 85%）
      level = '预测类型：潜力出众型 ';
      recommendation = '你目前成绩表现优秀，可以考虑报考双一流院校';
      suggestions.push('（一）你目前成绩表现优秀，考研上岸希望很大，值得肯定！');
      suggestions.push('（二）继续保持高效的学习节奏，重点研究报考院校的专业课真题，争取高分脱颖而出。');
      suggestions.push('（三）在稳定优势科目的同时，适度拓展相关领域知识，为复试或调剂留足空间。');

    } else {
      // 二、稳中求进型（985/211 上岸概率 0%–85%）
      level = '预测类型：稳中求进型 ';
      recommendation = '你已有一定基础，但冲击双一流院校仍存在风险。';
      suggestions.push('（一）你已有一定基础，但冲击高层次院校仍存在风险，建议优先考虑报考本校，把握更大。');
      suggestions.push('（二）接下来需重点强化数学和英语，制定每日可执行的学习计划，及时查漏补缺。');
      suggestions.push('（三）合理评估自身复习进度，若后期成绩有显著提升，也可适当关注比本校稍高层次的院校。');
    }

  } else if (data.prediction === 0) { // 预测为 本校
    if (data.probability >= 50) {
      // 三、务实保底型（本校上岸概率 50%–100%）
      level = '预测类型：务实保底型';
      recommendation = '当前成绩报考本校有较大把握。';
      suggestions.push('（一）当前成绩报考本校有较大把握，建议将主要精力放在巩固基础和熟悉本校考题风格上。');
      suggestions.push('（二）可积极参加学校组织的英语、数学强化班，系统提升弱项，提早进入备考状态。');
      suggestions.push('（三）若学有余力，后期成绩有显著提升，再结合模拟考试结果考虑是否调整目标，但务必以“保底”为前提。');

    } else {
      // 四、全力冲刺型（本校上岸概率 0%–50%）
      level = '预测类型：全力冲刺型';
      recommendation = '你目前有一定基础，但上岸仍有一定挑战。';
      suggestions.push('（一）你目前有一定基础，但冲击本校仍有一定挑战，建议将报考目标明确锚定在本校，集中精力提升关键科目。');
      suggestions.push('（二）接下来需要全力投入复习，充分利用线上课程、线下辅导等资源，重点强化数学和英语等薄弱环节。');
      suggestions.push('（三）时间较为紧张，请尽早进入高强度的复习节奏，坚持每日推进，同时也要保持信心，争取实现突破。');
    }

  } else if (data.prediction === -1) { // 预测为 积极调整型（上岸难度较大）
    level = '预测类型：积极调整型';
    recommendation = '虽有一定挑战，但需要全力投入，仍有实现可能。';
    suggestions.push('（一）考研虽有一定挑战，但只要合理定位、全力投入，仍有实现可能。');
    suggestions.push('（二）建议优先考虑报考本校，并充分利用线上线下资源，抓紧时间补强基础。');
    suggestions.push('（三）同时也推荐关注就业招聘信息，做好升学与求职的双重准备，保持积极心态。');

  } else { // 无法识别的预测结果
    level = '层次：无法识别';
    recommendation = '预测结果异常，请重试';
    suggestions.push('一、请检查输入的成绩是否合理');
    suggestions.push('二、若多次异常，联系管理员排查问题');
  }

  // 关键新增：返回判断标记（true = 积极调整型，false = 其他类型）
  return { 
    level, 
    recommendation, 
    suggestions, 
    prediction// 核心判断：prediction=-1即不显示概率
  };
}

// ===================== 关键修改5：渲染结果（根据标记控制概率是否显示） =====================
// 新增参数isAdjustmentType：控制“积极调整型”是否显示概率（默认false）
function displayResults(level, probability, recommendation, suggestions, prediction) {
  const predictionDetails = document.getElementById('prediction-details');
  const schoolRecommendation = document.getElementById('school-recommendation');

  if (!predictionDetails || !schoolRecommendation) {
    log('显示失败：未找到结果展示DOM元素', 'error');
    return;
  }

  // 关键修改：根据prediction判断概率显示内容
  let probabilityText = '';
  if (prediction === -1) { // 积极调整型：显示“上岸有难度”
    probabilityText = '上岸概率: 有难度';
  } else { // 其他类型：正常显示百分比（保留2位小数）
    probabilityText = `上岸概率: ${(Number(probability)).toFixed(2)}%`;
  }

  // 渲染预测结果到页面（使用修改后的probabilityText）
  predictionDetails.innerHTML = `
    <span style="color:#1976d2;font-weight:bold;">${level}</span><br>
    <span style="color:#1976d2;font-weight:bold;">${probabilityText}</span><br>
    <span style="color:#1976d2;font-weight:bold;">报考建议: ${recommendation}</span>
  `;

  // 渲染备考建议（原逻辑不变）
  schoolRecommendation.innerHTML = `<ul class="suggestion-list">${suggestions.map(s => `<li>${s}</li>`).join('')}</ul>`;
}
function showRecommendationButton() {
  const buttonContainer = document.getElementById('recommendation-button-container');
  if (buttonContainer) {
    buttonContainer.style.display = 'block';
    // 补充"重新预测"按钮（可选，方便用户重试）
    if (buttonContainer.innerHTML === '') {
      buttonContainer.innerHTML = `
        <button onclick="sendPredictionRequest()" style="padding:0.5rem 1rem; background:#1976d2; color:#fff; border:none; border-radius:4px; cursor:pointer;">
          重新发起预测
        </button>
      `;
    }
  }
}

// 暴露sendPredictionRequest到window，确保重新预测按钮可调用
window.sendPredictionRequest = sendPredictionRequest;
